创作者|正题_32.Python面向对象描述符运算符底层装饰器：闭包闭包参数内置装饰器类装饰器

篇首语：本文由编程笔记#小编为大家整理，主要介绍了32.Python面向对象描述符运算符底层装饰器：闭包-闭包参数-内置装饰器-类装饰器相关的知识，希望对你有一定的参考价值。

目录&＃xff1a;

• 每篇前言&＃xff1a;
• Python面向对象&＃xff08;五&＃xff09;
• • 1.1 描述符
  • 1.2 运算符底层调用的什么&＃xff1f;
  • 1.3 装饰器
  • • 第一部分——引入门
    • • &＃xff08;1&＃xff09;首先、咱再看遍闭包是啥&＃xff1a;
      • &＃xff08;2&＃xff09;然后&＃xff0c;咱稍微高级点&＃xff0c;看看闭包参数。
      • &＃xff08;3&＃xff09;最后&＃xff0c;就来看看第一种装饰器&＃xff1a;
      
      
    • 第二部分——类里面的内置装饰器
    • • &＃xff08;1&＃xff09;引入
      • &＃xff08;2&＃xff09;第一个是把类里面的方法变为属性&＃xff1a;
      • &＃xff08;3&＃xff09;静态方法
      • &＃xff08;4&＃xff09;第三个是类方法&＃xff1a;
      
      
    • 第三部分——最后阶段
    • • &＃xff08;1&＃xff09;类装饰器 必须使用__call__方法
      • &＃xff08;2&＃xff09;看看高级点的
      
      
    • 拓展一下呗——来个装饰器的习题
    
    
  
  

• 
  
  

  &＃x1f3c6;&＃x1f3c6;作者介绍&＃xff1a;【孤寒者】—CSDN全栈领域优质创作者、HDZ核心组成员、华为云享专家Python全栈领域博主、CSDN原力计划作者

  
  
• &＃x1f525;&＃x1f525;本文已收录于Python全栈系列专栏&＃xff1a;《Python全栈基础教程》
• &＃x1f525;&＃x1f525;热门专栏推荐&＃xff1a;《Django框架从入门到实战》、《爬虫从入门到精通系列教程》、《爬虫高级》、《前端系列教程》、《tornado一条龙&＃43;一个完整版项目》。
• &＃x1f4dd;​&＃x1f4dd;本专栏面向广大程序猿&＃xff0c;为的是大家都做到Python从入门到精通&＃xff0c;同时穿插有很多很多习题&＃xff0c;巩固学习。
• &＃x1f389;&＃x1f389;订阅专栏后可私聊进一千多人Python全栈交流群&＃xff08;手把手教学&＃xff0c;问题解答&＃xff09;&＃xff1b; 进群可领取Python全栈教程视频 &＃43; 多得数不过来的计算机书籍&＃xff1a;基础、Web、爬虫、数据分析、可视化、机器学习、深度学习、人工智能、算法、面试题等。
• &＃x1f680;&＃x1f680;加入我一起学习进步&＃xff0c;一个人可以走的很快&＃xff0c;一群人才能走的更远&＃xff01;

---

1.1 描述符

描述符协议&＃xff1a;python描述符是一个“绑定行为”的对象属性&＃xff0c;在描述符协议中&＃xff0c;它可以通过方法重写属性的访问。这些方法有__get__(), __set__(), 和__delete__()。
如果这些方法中的任何一个被定义在一个对象中&＃xff0c;这个对象就是一个描述符

举例说明&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
# 描述符&＃xff1a;描述符就是类里面的属性base
# 控制实例对象a访问 这个属性 &＃xff08;base) 可以做一些额外的操作
# 描述符 定义了__get__ __set__ __delete__ 当中的一种
class Base:
def __get__(self,instance,owner):
print(&＃39;恭喜玩家获得荒古宝典&＃39;)
def __set__(self, instance,value):
print(&＃39;强化%s&＃39;%value)
def __delete__(self,instance):
print(&＃39;武器已经损坏&＃39;)
class A:
base &＃61; Base()
#实例化
a &＃61; A()
a.base # __get__ 会直接输出__get__方法里面的内容
a.base &＃61; 50 # __set__ 会直接输出__set__方法里面的内容
del a.base # __delete__ 会直接输出__delete__方法里面的内容


1.2 运算符底层调用的什么&＃xff1f;

• &＃43;调用的是__add__

举例说明&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class A:
def __init__(self,num1,num2):
self.num1 &＃61; num1
self.num2 &＃61; num2
def __add__(self,other): #self 实例对象 &＃xff1b; other 另外一个实例对象
sum1 &＃61; self.num1 &＃43; other.num1
sum2 &＃61; self.num2 &＃43; other.num2
return sum1,sum2
a &＃61; A(1,2)
b &＃61; A(3,4)
print(a&＃43;b) #输出为 (4,6)


运算符方法&＃xff08;了解即可&＃xff09;

__add__(self,other) # x&＃43;y


__sub__(self,other) # x-y


__mul__(self,other) # x*y


__mod__(self,other) # x%y


__iadd__(self,other) # x&＃43;&＃61;y


__isub__(self,other) # x-&＃61;y


__radd__(self,other) # y&＃43;x


__rsub__(self,other) # y-x


__imul__(self,other) # x*&＃61;y


__imod__(self,other) # x%&＃61;y


1.3 装饰器

有这个玩意的原因&＃xff1a;python是一个动态语言&＃xff0c;因为一切都是对象。是一个脚本语言。

第一部分——引入门

&＃xff08;1&＃xff09;首先、咱再看遍闭包是啥&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
#闭包
def fun1():
print(&＃39;fun1&＃39;)
def fun2():
print(&＃39;fun2&＃39;)
return fun2
#fun1()() &＃61;&＃61;&＃61;> fun2()
a &＃61; fun1()
a() #会执行两个函数


&＃xff08;2&＃xff09;然后&＃xff0c;咱稍微高级点&＃xff0c;看看闭包参数。

这种方法比较麻烦&＃xff0c;所以下面就引入了装饰器&＃xff0c;和这个的功能一模一样&＃xff0c;不过
简单了许多&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
#闭包里面有参数 回调函数
def aa(fun): #fun &＃61; f1
print(&＃39;------------aa&＃39;)
def bb():
fun() #fun() &＃61; f1()
print(&＃39;----------bb&＃39;)
return bb
def f1():
print(&＃39;this is f1&＃39;)
def f2():
print(&＃39;this is f2&＃39;)
cc &＃61; aa(f1)
cc()


&＃xff08;3&＃xff09;最后&＃xff0c;就来看看第一种装饰器&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
# 装饰器 在不改变原有函数的基础上面增加额外的功能
# 装饰器
def aa(fun): #fun &＃61; f1
print(&＃39;------------aa&＃39;)
def bb():
fun() #fun() &＃61; f1()
print(&＃39;----------bb&＃39;)
return bb
# 装饰器 被装饰的函数名字&＃xff08;f1)会被当做参数传递给装饰函数&＃xff08;aa&＃xff09;
# 代码就是&＃xff1a; aa(f1)
# 装饰函数&＃xff08;aa&＃xff09;执行完它自己内部的代码之后&＃xff0c;会把它的结果返回给
# 被装饰的函数&＃xff08;f1&＃xff09;
# 代码就是&＃xff1a; f1 &＃61; aa(f1)
# 然后下面又是f1() 就相当于 aa(f1)()
&＃64;aa # 就相当于 f1 &＃61; aa(f1) 要使用嵌套函数里面的内容 aa(f1)(),就是最后调用的时候f1加个括号
# 而注意函数外部的只要用到装饰器就会执行&＃xff0c;而嵌套的内层函数需要调用才会执行&＃xff0c;所以
# 用处就是把重要的东西写到嵌套的内层函数&＃xff0c;在调用的时候才会执行
def f1():
print(&＃39;this is f1&＃39;)
def f2():
print(&＃39;this is f2&＃39;)
f1() #输出和上面一个一模一样


第二部分——类里面的内置装饰器

&＃xff08;1&＃xff09;引入

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class Base:
def fun(self):
print(&＃39;好好学习&＃xff0c;天天向上&＃39;)
b &＃61; Base()
b.fun() # 调用类里面的方法&＃xff0c;就会执行类里面的方法fun&＃xff0c;打印 好好学习&＃xff0c;天天向上


正题&＃xff1a;

&＃xff08;2&＃xff09;第一个是把类里面的方法变为属性&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class Base:
name &＃61; &＃39;孤寒者&＃39;
&＃64;property #将方法变为属性 更加简洁
def fun(self):
return(&＃39;好好学习&＃xff0c;天天向上&＃39;)
b &＃61; Base()
print(b.name) #属性的使用不需要加括号&＃xff1b;方法的使用才要加括号
print(b.fun) #现在类里面的方法fun就变成了类的属性


&＃xff08;3&＃xff09;静态方法

• 第二个是把类里面的方法变为静态方法&＃xff0c;让其可以像使用函数一样去使用&＃xff0c;而不需要再实例化才能使用&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class Base:
&＃64;staticmethod #静态方法 方法能够像函数一样的去使用&＃xff0c; 比如在类里面&＃xff0c;你要写一些闭包什么的就可以在这里面写&＃xff0c;相当于扩展了一些功能。
def fun2(): # 注意&＃xff1a;这里已经不需要self 和class类断开联系
print(&＃39;过年好&＃xff0c;新年好&＃39;)
#再来个不加装饰器的
def func(self):
print(&＃39;这是普通方法&＃39;)
Base.fun2() # fun2已经变为静态方法&＃xff0c;可以像使用函数一样的使用
# 输出为&＃xff1a; 过年好&＃xff0c;新年好
# Base是类名&＃xff1b;Base() 就是实例化
Base().func() # 而没有使用装饰器的方法就需要先实例化&＃xff0c;才能去使用


&＃xff08;4&＃xff09;第三个是类方法&＃xff1a;

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class Base:
def func(self):
print(&＃39;这是普通方法&＃39;)
&＃64;classmethod
def fun3(cls): # 没有self 和实例无关&＃xff0c;这是类方法 &＃xff1b; 有self的是实例方法&＃xff0c;需要先实例化才能使用
print(&＃39;cls类方法&＃39;)
cls().func() # cls 代表类本身&＃xff0c;即Base这个类
# 类方法的使用&＃xff0c;也不用实例化 直接类名点方法
Base.fun3()


第三部分——最后阶段

&＃xff08;1&＃xff09;类装饰器 必须使用__call__方法

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class Base:
def __init__(self,name):
self.name &＃61; name
def __call__(self,*args,**kwargs):
print(&＃39;this is call&＃39;)
&＃64;Base # func &＃61; Base(func) 被装饰函数&＃xff08;func&＃xff09;当做参数传递给装饰函数&＃xff08;Base&＃xff09;
def func():
print(&＃39;this is func&＃39;)
func() # 此处的括号就相当于 func() &＃61; Base(func)()
# __call__方法只要实例化就会被调用
#输出为&＃xff1a; this is call


&＃xff08;2&＃xff09;看看高级点的

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
class Base:
def __init__(self,fun):
self.fun &＃61; fun
def __call__(self,*args,**kwargs):
self.fun() #就会打印 this is func
print(&＃39;this is call&＃39;)
def __str__(self):
return &＃39;this is str&＃39;
&＃64;Base # func &＃61; Base(func) 相当于实例化 被装饰函数&＃xff08;func&＃xff09;当做参数传递给装饰函数&＃xff08;Base&＃xff09;
def func():
print(&＃39;this is func&＃39;)
func() # 此处的括号就相当于 func() &＃61; Base(func)()
# __call__方法只要实例化就会被调用
print(func) # 打印类的实例&＃xff0c;就会调用类里面的__str__方法


拓展一下呗——来个装饰器的习题

• 测试type和isinstance两个函数&＃xff0c;哪个速度更加的快&＃xff1f;

需要注意的是&＃xff1a;程序运行速度比较快 只查看上面两个函数 运行一次的时间显示不出来效果&＃xff0c;可以查看循环一万次的时间。

# -*- coding: utf-8 -*-
"""
__author__ &＃61; 孤寒者
"""
#time.time() 计算目前的时间 时间戳&＃xff08;格林威治时间&＃xff0c; 1970.1.1到现在的总秒数&＃xff09;
import time
def funa(fun):
def funb():
a &＃61; time.time()
fun()
b &＃61; time.time()
print(&＃39;函数运行了%s&＃39;%(b-a))
return funb
&＃64;funa
def f1():
for i in range(100000):
type(1)
f1()
&＃64;funa
def f2():
for i in range(100000):
isinstance(1,int)
f2()